home *** CD-ROM | disk | FTP | other *** search
/ Champak 40 / Vol 40.iso / games / ufo_comm.swf / scripts / DefineSprite_240 / frame_13 / DoAction.as
Encoding:
Text File  |  2007-04-25  |  66.9 KB  |  1,301 lines

  1. var ┬º\x01┬º = 245;
  2. while(eval("\x01") != 245)
  3. {
  4.    if(eval("\x01") == 517)
  5.    {
  6.       break;
  7.    }
  8.    if(eval("\x01") == 424)
  9.    {
  10.       break;
  11.    }
  12.    if(eval("\x01") == 405)
  13.    {
  14.       break;
  15.    }
  16.    if(eval("\x01") == 310)
  17.    {
  18.       break;
  19.    }
  20.    if(eval("\x01") == 197)
  21.    {
  22.       break;
  23.    }
  24.    if(eval("\x01") == 769)
  25.    {
  26.       break;
  27.    }
  28.    if(eval("\x01") == 385)
  29.    {
  30.       break;
  31.    }
  32.    if(eval("\x01") == 937)
  33.    {
  34.       break;
  35.    }
  36.    if(eval("\x01") == 888)
  37.    {
  38.       break;
  39.    }
  40.    if(eval("\x01") == 264)
  41.    {
  42.       break;
  43.    }
  44.    if(eval("\x01") == 461)
  45.    {
  46.       break;
  47.    }
  48.    if(eval("\x01") == 98)
  49.    {
  50.       break;
  51.    }
  52.    if(eval("\x01") == 757)
  53.    {
  54.       set("\x01",eval("\x01") - 560);
  55.       break;
  56.    }
  57.    if(eval("\x01") == 296)
  58.    {
  59.       set("\x01",eval("\x01") + 359);
  60.       if(┬º┬ºpop())
  61.       {
  62.          set("\x01",eval("\x01") - 290);
  63.       }
  64.    }
  65.    else if(eval("\x01") == 365)
  66.    {
  67.       set("\x01",eval("\x01") - 55);
  68.       ┬º┬ºpush(true);
  69.    }
  70.    else if(eval("\x01") == 291)
  71.    {
  72.       set("\x01",eval("\x01") + 226);
  73.       ┬º┬ºpush(true);
  74.    }
  75.    else if(eval("\x01") == 34)
  76.    {
  77.       set("\x01",eval("\x01") + 903);
  78.       ┬º┬ºpush(true);
  79.    }
  80.    else
  81.    {
  82.       if(eval("\x01") == 421)
  83.       {
  84.          set("\x01",eval("\x01") - 421);
  85.       }
  86.       else
  87.       {
  88.          if(eval("\x01") == 643)
  89.          {
  90.             set("\x01",eval("\x01") - 152);
  91.             if(┬º┬ºpop())
  92.             {
  93.                set("\x01",eval("\x01") + 278);
  94.             }
  95.             continue;
  96.          }
  97.          if(eval("\x01") == 655)
  98.          {
  99.             set("\x01",eval("\x01") - 290);
  100.             ┬º┬ºpush(┬º┬ºpop() > ┬º┬ºpop());
  101.          }
  102.          else if(eval("\x01") == 280)
  103.          {
  104.             set("\x01",eval("\x01") - 246);
  105.             loop1:
  106.             while(true)
  107.             {
  108.                set(┬º┬ºpop(),eval(┬º┬ºpop()) + 214);
  109.                if(┬º┬ºpop())
  110.                {
  111.                   set("\x01",eval("\x01") - 327);
  112.                }
  113.                loop2:
  114.                while(true)
  115.                {
  116.                   if(eval("\x01") == 186)
  117.                   {
  118.                      set("\x01",eval("\x01") + 419);
  119.                      ┬º┬ºpush(true);
  120.                   }
  121.                   else
  122.                   {
  123.                      if(eval("\x01") == 720)
  124.                      {
  125.                         continue loop1;
  126.                      }
  127.                      if(eval("\x01") == 684)
  128.                      {
  129.                         set("\x01",eval("\x01") - 664);
  130.                         if(┬º┬ºpop())
  131.                         {
  132.                            set("\x01",eval("\x01") + 294);
  133.                         }
  134.                      }
  135.                      else if(eval("\x01") == 179)
  136.                      {
  137.                         set("\x01",eval("\x01") + 113);
  138.                         if(┬º┬ºpop())
  139.                         {
  140.                            set("\x01",eval("\x01") + 664);
  141.                         }
  142.                      }
  143.                      else
  144.                      {
  145.                         if(eval("\x01") != 605)
  146.                         {
  147.                            if(eval("\x01") == 895)
  148.                            {
  149.                               set("\x01",eval("\x01") - 459);
  150.                               break;
  151.                            }
  152.                            if(eval("\x01") == 248)
  153.                            {
  154.                               set("\x01",eval("\x01") + 217);
  155.                               this.swapDepths(500);
  156.                            }
  157.                            if(eval("\x01") == 465)
  158.                            {
  159.                               set("\x01",eval("\x01") - 270);
  160.                               ┬º┬ºpush(true);
  161.                            }
  162.                            else if(eval("\x01") == 607)
  163.                            {
  164.                               set("\x01",eval("\x01") - 66);
  165.                               ┬º┬ºpush(true);
  166.                            }
  167.                            else
  168.                            {
  169.                               if(eval("\x01") == 934)
  170.                               {
  171.                                  set("\x01",eval("\x01") - 327);
  172.                                  ┬º┬ºpush(┬º┬ºpop() and ┬º┬ºpop());
  173.                                  break;
  174.                               }
  175.                               if(eval("\x01") == 453)
  176.                               {
  177.                                  set("\x01",eval("\x01") + 536);
  178.                                  break;
  179.                               }
  180.                               if(eval("\x01") == 195)
  181.                               {
  182.                                  set("\x01",eval("\x01") + 258);
  183.                                  if(┬º┬ºpop())
  184.                                  {
  185.                                     set("\x01",eval("\x01") + 536);
  186.                                  }
  187.                               }
  188.                               else if(eval("\x01") == 989)
  189.                               {
  190.                                  set("\x01",eval("\x01") - 810);
  191.                                  ┬º┬ºpush(true);
  192.                               }
  193.                               else if(eval("\x01") == 541)
  194.                               {
  195.                                  set("\x01",eval("\x01") + 372);
  196.                                  if(┬º┬ºpop())
  197.                                  {
  198.                                     set("\x01",eval("\x01") + 79);
  199.                                  }
  200.                               }
  201.                               else if(eval("\x01") == 314)
  202.                               {
  203.                                  set("\x01",eval("\x01") + 536);
  204.                                  ┬º┬ºpush(true);
  205.                               }
  206.                               else
  207.                               {
  208.                                  if(eval("\x01") == 292)
  209.                                  {
  210.                                     set("\x01",eval("\x01") + 664);
  211.                                     if(┬º┬ºpop() == 423)
  212.                                     {
  213.                                        set("\x01",eval("\x01") - 174);
  214.                                        break;
  215.                                     }
  216.                                     if(eval("\x01") == 651)
  217.                                     {
  218.                                        set("\x01",eval("\x01") - 388);
  219.                                        x = random(2) + 1;
  220.                                        y = random(2) + 1;
  221.                                        if(x == y)
  222.                                        {
  223.                                           this._xscale = 100;
  224.                                           this.dreapta = false;
  225.                                           this.stanga = true;
  226.                                        }
  227.                                        else
  228.                                        {
  229.                                           this._xscale = -100;
  230.                                           this.dreapta = true;
  231.                                           this.stanga = false;
  232.                                        }
  233.                                        this.ok = true;
  234.                                        this.mers = false;
  235.                                        this.dead = false;
  236.                                        this.speed = 0;
  237.                                        this.speedX = 5;
  238.                                        this.counter = 0;
  239.                                        this.swapDepths(_root.oiCounter);
  240.                                        _root.oiCounter = _root.oiCounter + 1;
  241.                                        break;
  242.                                     }
  243.                                     if(eval("\x01") == 263)
  244.                                     {
  245.                                        set("\x01",eval("\x01") - 263);
  246.                                     }
  247.                                     break;
  248.                                  }
  249.                                  if(eval("\x01") == 956)
  250.                                  {
  251.                                     set("\x01",eval("\x01") - 470);
  252.                                     ┬º┬ºpush(true);
  253.                                  }
  254.                                  else if(eval("\x01") == 725)
  255.                                  {
  256.                                     set("\x01",eval("\x01") + 170);
  257.                                     if(┬º┬ºpop())
  258.                                     {
  259.                                        set("\x01",eval("\x01") - 459);
  260.                                     }
  261.                                  }
  262.                                  else if(eval("\x01") == 436)
  263.                                  {
  264.                                     set("\x01",eval("\x01") + 284);
  265.                                     ┬º┬ºpush(true);
  266.                                  }
  267.                                  else
  268.                                  {
  269.                                     if(eval("\x01") == 913)
  270.                                     {
  271.                                        set("\x01",eval("\x01") + 79);
  272.                                        loop3:
  273.                                        while(┬º┬ºpop() == 893)
  274.                                        {
  275.                                           set("\x01",eval("\x01") - 733);
  276.                                           ┬º┬ºpush(true);
  277.                                           while(true)
  278.                                           {
  279.                                              if(eval("\x01") == 462)
  280.                                              {
  281.                                                 set("\x01",eval("\x01") - 235);
  282.                                                 ┬º┬ºpush(true);
  283.                                                 continue;
  284.                                              }
  285.                                              if(eval("\x01") == 571)
  286.                                              {
  287.                                                 set("\x01",eval("\x01") - 198);
  288.                                                 ┬º┬ºpush(true);
  289.                                                 continue;
  290.                                              }
  291.                                              if(eval("\x01") == 584)
  292.                                              {
  293.                                                 break;
  294.                                              }
  295.                                              if(eval("\x01") == 373)
  296.                                              {
  297.                                                 set("\x01",eval("\x01") - 198);
  298.                                                 if(┬º┬ºpop())
  299.                                                 {
  300.                                                    set("\x01",eval("\x01") + 718);
  301.                                                 }
  302.                                                 continue;
  303.                                              }
  304.                                              if(eval("\x01") == 939)
  305.                                              {
  306.                                                 set("\x01",eval("\x01") - 445);
  307.                                                 if(┬º┬ºpop())
  308.                                                 {
  309.                                                    set("\x01",eval("\x01") + 77);
  310.                                                 }
  311.                                                 continue;
  312.                                              }
  313.                                              if(eval("\x01") == 187)
  314.                                              {
  315.                                                 set("\x01",eval("\x01") + 397);
  316.                                                 loop5:
  317.                                                 while(true)
  318.                                                 {
  319.                                                    if(eval(┬º┬ºpop()) == 786)
  320.                                                    {
  321.                                                       set("\x01",eval("\x01") - 75);
  322.                                                       if(┬º┬ºpop())
  323.                                                       {
  324.                                                          set("\x01",eval("\x01") + 1);
  325.                                                       }
  326.                                                    }
  327.                                                    else
  328.                                                    {
  329.                                                       if(eval("\x01") == 991)
  330.                                                       {
  331.                                                          break;
  332.                                                       }
  333.                                                       if(eval("\x01") == 711)
  334.                                                       {
  335.                                                          set("\x01",eval("\x01") + 1);
  336.                                                          ┬º┬ºpop();
  337.                                                          removeMovieClip(_root);
  338.                                                          break loop2;
  339.                                                       }
  340.                                                       if(eval("\x01") == 286)
  341.                                                       {
  342.                                                          set("\x01",eval("\x01") - 34);
  343.                                                          ┬º┬ºpush(true);
  344.                                                       }
  345.                                                       else
  346.                                                       {
  347.                                                          if(eval("\x01") == 49)
  348.                                                          {
  349.                                                             set("\x01",eval("\x01") + 455);
  350.                                                             break loop2;
  351.                                                          }
  352.                                                          if(eval("\x01") == 789)
  353.                                                          {
  354.                                                             set("\x01",eval("\x01") - 619);
  355.                                                             if(┬º┬ºpop())
  356.                                                             {
  357.                                                                set("\x01",eval("\x01") + 281);
  358.                                                             }
  359.                                                          }
  360.                                                          else
  361.                                                          {
  362.                                                             if(eval("\x01") == 347)
  363.                                                             {
  364.                                                                set("\x01",eval("\x01") + 542);
  365.                                                                stop();
  366.                                                                break loop2;
  367.                                                             }
  368.                                                             if(eval("\x01") == 712)
  369.                                                             {
  370.                                                                set("\x01",eval("\x01") - 148);
  371.                                                                ┬º┬ºpush(true);
  372.                                                             }
  373.                                                             else if(eval("\x01") == 564)
  374.                                                             {
  375.                                                                set("\x01",eval("\x01") - 433);
  376.                                                                if(┬º┬ºpop())
  377.                                                                {
  378.                                                                   set("\x01",eval("\x01") + 811);
  379.                                                                }
  380.                                                             }
  381.                                                             else
  382.                                                             {
  383.                                                                if(eval("\x01") == 334)
  384.                                                                {
  385.                                                                   set("\x01",eval("\x01") + 609);
  386.                                                                   break loop2;
  387.                                                                }
  388.                                                                if(eval("\x01") == 50)
  389.                                                                {
  390.                                                                   set("\x01",eval("\x01") - 50);
  391.                                                                   break loop2;
  392.                                                                }
  393.                                                                if(eval("\x01") == 889)
  394.                                                                {
  395.                                                                   set("\x01",eval("\x01") - 100);
  396.                                                                   ┬º┬ºpush(true);
  397.                                                                }
  398.                                                                else
  399.                                                                {
  400.                                                                   if(eval("\x01") == 952)
  401.                                                                   {
  402.                                                                      set("\x01",eval("\x01") - 666);
  403.                                                                      break loop2;
  404.                                                                   }
  405.                                                                   if(eval("\x01") == 504)
  406.                                                                   {
  407.                                                                      set("\x01",eval("\x01") + 66);
  408.                                                                      ┬º┬ºpush(true);
  409.                                                                   }
  410.                                                                   else if(eval("\x01") == 570)
  411.                                                                   {
  412.                                                                      set("\x01",eval("\x01") - 236);
  413.                                                                      if(┬º┬ºpop())
  414.                                                                      {
  415.                                                                         set("\x01",eval("\x01") + 609);
  416.                                                                      }
  417.                                                                   }
  418.                                                                   else
  419.                                                                   {
  420.                                                                      if(eval("\x01") == 170)
  421.                                                                      {
  422.                                                                         set("\x01",eval("\x01") + 281);
  423.                                                                         set(┬º┬ºpop(),eval("\x01") - 451);
  424.                                                                         ┬º┬ºpush(┬º┬ºpop() >> (┬º┬ºpop() >>> ┬º┬ºpop()));
  425.                                                                         break loop2;
  426.                                                                      }
  427.                                                                      if(eval("\x01") == 16)
  428.                                                                      {
  429.                                                                         set("\x01",eval("\x01") + 331);
  430.                                                                         if(┬º┬ºpop())
  431.                                                                         {
  432.                                                                            set("\x01",eval("\x01") + 542);
  433.                                                                         }
  434.                                                                      }
  435.                                                                      else if(eval("\x01") == 451)
  436.                                                                      {
  437.                                                                         set("\x01",eval("\x01") + 335);
  438.                                                                         ┬º┬ºpush(true);
  439.                                                                      }
  440.                                                                      else
  441.                                                                      {
  442.                                                                         if(eval("\x01") != 943)
  443.                                                                         {
  444.                                                                            if(eval("\x01") == 131)
  445.                                                                            {
  446.                                                                               set("\x01",eval("\x01") + 811);
  447.                                                                               play();
  448.                                                                               prevFrame();
  449.                                                                            }
  450.                                                                            break loop2;
  451.                                                                         }
  452.                                                                         set("\x01",eval("\x01") - 678);
  453.                                                                         ┬º┬ºpush(true);
  454.                                                                      }
  455.                                                                   }
  456.                                                                }
  457.                                                             }
  458.                                                          }
  459.                                                       }
  460.                                                    }
  461.                                                    while(true)
  462.                                                    {
  463.                                                       if(eval("\x01") == 70)
  464.                                                       {
  465.                                                          set("\x01",eval("\x01") - 54);
  466.                                                          ┬º┬ºpush(true);
  467.                                                          continue;
  468.                                                       }
  469.                                                       if(eval("\x01") == 101)
  470.                                                       {
  471.                                                          break;
  472.                                                       }
  473.                                                       if(eval("\x01") == 560)
  474.                                                       {
  475.                                                          set("\x01",eval("\x01") + 392);
  476.                                                          if(┬º┬ºpop())
  477.                                                          {
  478.                                                             set("\x01",eval("\x01") - 666);
  479.                                                          }
  480.                                                          continue;
  481.                                                       }
  482.                                                       if(eval("\x01") == 252)
  483.                                                       {
  484.                                                          set("\x01",eval("\x01") - 203);
  485.                                                          if(┬º┬ºpop())
  486.                                                          {
  487.                                                             set("\x01",eval("\x01") + 455);
  488.                                                          }
  489.                                                          continue;
  490.                                                       }
  491.                                                       if(eval("\x01") == 942)
  492.                                                       {
  493.                                                          set("\x01",eval("\x01") - 382);
  494.                                                          ┬º┬ºpush(true);
  495.                                                          continue;
  496.                                                       }
  497.                                                       if(eval("\x01") == 265)
  498.                                                       {
  499.                                                          set("\x01",eval("\x01") - 164);
  500.                                                          if(┬º┬ºpop())
  501.                                                          {
  502.                                                             set("\x01",eval("\x01") + 890);
  503.                                                          }
  504.                                                          continue;
  505.                                                       }
  506.                                                       continue loop5;
  507.                                                    }
  508.                                                    set("\x01",eval("\x01") + 890);
  509.                                                    break loop2;
  510.                                                 }
  511.                                                 set("\x01",eval("\x01") - 941);
  512.                                                 if(_root.sunet)
  513.                                                 {
  514.                                                    _root.sfor.start(0,999);
  515.                                                 }
  516.                                                 break loop2;
  517.                                              }
  518.                                              if(eval("\x01") == 435)
  519.                                              {
  520.                                                 set("\x01",eval("\x01") - 248);
  521.                                                 if(┬º┬ºpop())
  522.                                                 {
  523.                                                    set("\x01",eval("\x01") + 397);
  524.                                                 }
  525.                                                 continue;
  526.                                              }
  527.                                              if(eval("\x01") == 793)
  528.                                              {
  529.                                                 set("\x01",eval("\x01") - 793);
  530.                                                 break loop2;
  531.                                              }
  532.                                              if(eval("\x01") == 956)
  533.                                              {
  534.                                                 set("\x01",eval("\x01") - 17);
  535.                                                 ┬º┬ºpush(true);
  536.                                                 continue;
  537.                                              }
  538.                                              if(eval("\x01") == 160)
  539.                                              {
  540.                                                 set("\x01",eval("\x01") + 500);
  541.                                                 if(┬º┬ºpop())
  542.                                                 {
  543.                                                    set("\x01",eval("\x01") - 460);
  544.                                                 }
  545.                                                 continue;
  546.                                              }
  547.                                              if(eval("\x01") == 227)
  548.                                              {
  549.                                                 set("\x01",eval("\x01") + 166);
  550.                                                 if(┬º┬ºpop())
  551.                                                 {
  552.                                                    set("\x01",eval("\x01") + 563);
  553.                                                 }
  554.                                                 continue;
  555.                                              }
  556.                                              if(eval("\x01") == 175)
  557.                                              {
  558.                                                 set("\x01",eval("\x01") + 718);
  559.                                                 play();
  560.                                                 ┬º┬ºpush(┬º┬ºpop() / ┬º┬ºpop());
  561.                                                 break loop2;
  562.                                              }
  563.                                              if(eval("\x01") == 393)
  564.                                              {
  565.                                                 set("\x01",eval("\x01") + 563);
  566.                                                 break loop2;
  567.                                              }
  568.                                              if(eval("\x01") == 494)
  569.                                              {
  570.                                                 set("\x01",eval("\x01") + 77);
  571.                                                 break loop2;
  572.                                              }
  573.                                              if(eval("\x01") == 660)
  574.                                              {
  575.                                                 set("\x01",eval("\x01") - 460);
  576.                                                 prevFrame();
  577.                                                 break loop2;
  578.                                              }
  579.                                              if(eval("\x01") == 200)
  580.                                              {
  581.                                                 set("\x01",eval("\x01") + 235);
  582.                                                 ┬º┬ºpush(true);
  583.                                                 continue;
  584.                                              }
  585.                                              continue loop3;
  586.                                           }
  587.                                           set("\x01",eval("\x01") + 209);
  588.                                        }
  589.                                        break;
  590.                                     }
  591.                                     if(eval("\x01") == 486)
  592.                                     {
  593.                                        set("\x01",eval("\x01") - 459);
  594.                                        if(┬º┬ºpop())
  595.                                        {
  596.                                           set("\x01",eval("\x01") + 536);
  597.                                        }
  598.                                     }
  599.                                     else
  600.                                     {
  601.                                        if(eval("\x01") == 27)
  602.                                        {
  603.                                           set("\x01",eval("\x01") + 536);
  604.                                           prevFrame();
  605.                                           break;
  606.                                        }
  607.                                        if(eval("\x01") == 563)
  608.                                        {
  609.                                           set("\x01",eval("\x01") + 121);
  610.                                           ┬º┬ºpush(true);
  611.                                        }
  612.                                        else if(eval("\x01") == 344)
  613.                                        {
  614.                                           set("\x01",eval("\x01") + 381);
  615.                                           ┬º┬ºpush(true);
  616.                                        }
  617.                                        else
  618.                                        {
  619.                                           if(eval("\x01") == 141)
  620.                                           {
  621.                                              set("\x01",eval("\x01") + 203);
  622.                                              break;
  623.                                           }
  624.                                           if(eval("\x01") == 20)
  625.                                           {
  626.                                              set("\x01",eval("\x01") + 294);
  627.                                              break;
  628.                                           }
  629.                                           if(eval("\x01") != 850)
  630.                                           {
  631.                                              if(eval("\x01") == 992)
  632.                                              {
  633.                                                 set("\x01",eval("\x01") - 812);
  634.                                                 this.scoreBar = function()
  635.                                                 {
  636.                                                    if(_root.life >= 0)
  637.                                                    {
  638.                                                       _root.ufo.shape.play();
  639.                                                       _root.life -= random(15) + 1;
  640.                                                       _root.lifeBar.gotoAndStop(_root.life);
  641.                                                    }
  642.                                                    else
  643.                                                    {
  644.                                                       _root.life = 0;
  645.                                                       _root[┬º┬ºconstant(6)][┬º┬ºconstant(7)](_root.life + 1);
  646.                                                    }
  647.                                                 };
  648.                                                 break;
  649.                                              }
  650.                                              if(eval("\x01") == 180)
  651.                                              {
  652.                                                 set("\x01",eval("\x01") - 180);
  653.                                              }
  654.                                              break;
  655.                                           }
  656.                                           set("\x01",eval("\x01") - 709);
  657.                                           if(┬º┬ºpop())
  658.                                           {
  659.                                              set("\x01",eval("\x01") + 203);
  660.                                           }
  661.                                        }
  662.                                     }
  663.                                  }
  664.                               }
  665.                            }
  666.                            continue;
  667.                            break;
  668.                         }
  669.                         set("\x01",eval("\x01") - 357);
  670.                         if(┬º┬ºpop())
  671.                         {
  672.                            set("\x01",eval("\x01") + 217);
  673.                         }
  674.                      }
  675.                   }
  676.                }
  677.             }
  678.          }
  679.          else
  680.          {
  681.             if(eval("\x01") == 544)
  682.             {
  683.                set("\x01",eval("\x01") - 83);
  684.                if(┬º┬ºpop())
  685.                {
  686.                   set("\x01",eval("\x01") - 76);
  687.                }
  688.                continue;
  689.             }
  690.             if(eval("\x01") == 416)
  691.             {
  692.                set("\x01",eval("\x01") - 318);
  693.                ┬º┬ºpop() extends ┬º┬ºpop();
  694.                nextFrame();
  695.             }
  696.             else
  697.             {
  698.                if(eval("\x01") == 719)
  699.                {
  700.                   set("\x01",eval("\x01") - 303);
  701.                   if(┬º┬ºpop())
  702.                   {
  703.                      set("\x01",eval("\x01") - 318);
  704.                   }
  705.                   continue;
  706.                }
  707.                if(eval("\x01") == 72)
  708.                {
  709.                   set("\x01",eval("\x01") + 816);
  710.                }
  711.                else
  712.                {
  713.                   if(eval("\x01") == 756)
  714.                   {
  715.                      set("\x01",eval("\x01") - 684);
  716.                      if(┬º┬ºpop())
  717.                      {
  718.                         set("\x01",eval("\x01") + 816);
  719.                      }
  720.                      continue;
  721.                   }
  722.                   if(eval("\x01") == 62)
  723.                   {
  724.                      set("\x01",eval("\x01") + 695);
  725.                      if(┬º┬ºpop())
  726.                      {
  727.                         set("\x01",eval("\x01") - 560);
  728.                      }
  729.                      continue;
  730.                   }
  731.                   if(eval("\x01") == 491)
  732.                   {
  733.                      set("\x01",eval("\x01") + 278);
  734.                   }
  735.                }
  736.             }
  737.          }
  738.       }
  739.    }
  740. }
  741. with(§§pop())
  742. {
  743.    loop0:
  744.    while(true)
  745.    {
  746.       set("\x01",eval("\x01") - 113);
  747.       ┬º┬ºpush(true);
  748.       loop1:
  749.       while(true)
  750.       {
  751.          if(eval("\x01") == 348)
  752.          {
  753.             continue loop0;
  754.          }
  755.          if(eval("\x01") == 235)
  756.          {
  757.             set("\x01",eval("\x01") + 508);
  758.             if(┬º┬ºpop())
  759.             {
  760.                set("\x01",eval("\x01") - 488);
  761.             }
  762.          }
  763.          else
  764.          {
  765.             if(eval("\x01") == 81)
  766.             {
  767.                set("\x01",eval("\x01") + 670);
  768.                break;
  769.             }
  770.             if(eval("\x01") == 904)
  771.             {
  772.                set("\x01",eval("\x01") - 609);
  773.                if(┬º┬ºpop())
  774.                {
  775.                   set("\x01",eval("\x01") + 473);
  776.                }
  777.             }
  778.             else if(eval("\x01") == 197)
  779.             {
  780.                set("\x01",eval("\x01") + 739);
  781.                ┬º┬ºpush(true);
  782.             }
  783.             else if(eval("\x01") == 768)
  784.             {
  785.                set("\x01",eval("\x01") - 140);
  786.                ┬º┬ºpush(true);
  787.             }
  788.             else
  789.             {
  790.                if(eval("\x01") == 211)
  791.                {
  792.                   set("\x01",eval("\x01") + 774);
  793.                }
  794.                if(eval("\x01") == 736)
  795.                {
  796.                   set("\x01",eval("\x01") - 158);
  797.                   if(┬º┬ºpop())
  798.                   {
  799.                      set("\x01",eval("\x01") + 104);
  800.                   }
  801.                }
  802.                else
  803.                {
  804.                   if(eval("\x01") == 121)
  805.                   {
  806.                      set("\x01",eval("\x01") + 386);
  807.                      _root[┬º┬ºconstant(6)][┬º┬ºconstant(7)](┬º┬ºpop() >> ┬º┬ºpop());
  808.                      ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  809.                      break;
  810.                   }
  811.                   if(eval("\x01") == 682)
  812.                   {
  813.                      set("\x01",eval("\x01") + 37);
  814.                      ┬º┬ºpush(true);
  815.                   }
  816.                   else
  817.                   {
  818.                      if(eval("\x01") == 295)
  819.                      {
  820.                         set("\x01",eval("\x01") + 473);
  821.                         break;
  822.                      }
  823.                      if(eval("\x01") == 255)
  824.                      {
  825.                         set("\x01",eval("\x01") + 616);
  826.                         ┬º┬ºpush(true);
  827.                      }
  828.                      else if(eval("\x01") == 643)
  829.                      {
  830.                         set("\x01",eval("\x01") - 491);
  831.                         ┬º┬ºpush(true);
  832.                      }
  833.                      else
  834.                      {
  835.                         if(eval("\x01") == 743)
  836.                         {
  837.                            set("\x01",eval("\x01") - 488);
  838.                            prevFrame();
  839.                            break;
  840.                         }
  841.                         if(eval("\x01") == 732)
  842.                         {
  843.                            set("\x01",eval("\x01") - 89);
  844.                            break;
  845.                         }
  846.                         if(eval("\x01") == 871)
  847.                         {
  848.                            set("\x01",eval("\x01") - 421);
  849.                            if(┬º┬ºpop())
  850.                            {
  851.                               set("\x01",eval("\x01") - 222);
  852.                            }
  853.                         }
  854.                         else if(eval("\x01") == 751)
  855.                         {
  856.                            set("\x01",eval("\x01") - 135);
  857.                            ┬º┬ºpush(true);
  858.                         }
  859.                         else
  860.                         {
  861.                            if(eval("\x01") == 450)
  862.                            {
  863.                               set("\x01",eval("\x01") - 222);
  864.                               break;
  865.                            }
  866.                            if(eval("\x01") == 218)
  867.                            {
  868.                               set("\x01",eval("\x01") + 544);
  869.                            }
  870.                            if(eval("\x01") == 762)
  871.                            {
  872.                               set("\x01",eval("\x01") + 142);
  873.                               ┬º┬ºpush(true);
  874.                            }
  875.                            else if(eval("\x01") == 228)
  876.                            {
  877.                               set("\x01",eval("\x01") + 508);
  878.                               ┬º┬ºpush(true);
  879.                            }
  880.                            else
  881.                            {
  882.                               if(eval("\x01") == 578)
  883.                               {
  884.                                  set("\x01",eval("\x01") + 104);
  885.                                  break;
  886.                               }
  887.                               if(eval("\x01") == 628)
  888.                               {
  889.                                  set("\x01",eval("\x01") - 547);
  890.                                  if(┬º┬ºpop())
  891.                                  {
  892.                                     set("\x01",eval("\x01") + 670);
  893.                                  }
  894.                               }
  895.                               else if(eval("\x01") == 719)
  896.                               {
  897.                                  set("\x01",eval("\x01") - 598);
  898.                                  if(┬º┬ºpop())
  899.                                  {
  900.                                     set("\x01",eval("\x01") + 386);
  901.                                  }
  902.                               }
  903.                               else if(eval("\x01") == 616)
  904.                               {
  905.                                  set("\x01",eval("\x01") - 339);
  906.                                  if(┬º┬ºpop())
  907.                                  {
  908.                                     set("\x01",eval("\x01") - 80);
  909.                                  }
  910.                               }
  911.                               else
  912.                               {
  913.                                  if(eval("\x01") == 277)
  914.                                  {
  915.                                     set("\x01",eval("\x01") - 80);
  916.                                     stop();
  917.                                     loop2:
  918.                                     while(true)
  919.                                     {
  920.                                        if(┬º┬ºpop())
  921.                                        {
  922.                                           set("\x01",eval("\x01") - 157);
  923.                                           ┬º┬ºpush(true);
  924.                                        }
  925.                                        else if(eval("\x01") == 267)
  926.                                        {
  927.                                           set("\x01",eval("\x01") - 35);
  928.                                           if(┬º┬ºpop())
  929.                                           {
  930.                                              set("\x01",eval("\x01") + 424);
  931.                                           }
  932.                                        }
  933.                                        else if(eval("\x01") == 766)
  934.                                        {
  935.                                           set("\x01",eval("\x01") + 15);
  936.                                           if(┬º┬ºpop())
  937.                                           {
  938.                                              set("\x01",eval("\x01") - 164);
  939.                                           }
  940.                                        }
  941.                                        else
  942.                                        {
  943.                                           if(eval("\x01") == 232)
  944.                                           {
  945.                                              break;
  946.                                           }
  947.                                           if(eval("\x01") == 247)
  948.                                           {
  949.                                              set("\x01",eval("\x01") - 247);
  950.                                              break loop1;
  951.                                           }
  952.                                           if(eval("\x01") != 499)
  953.                                           {
  954.                                              break loop1;
  955.                                           }
  956.                                           set("\x01",eval("\x01") - 342);
  957.                                           if(┬º┬ºpop())
  958.                                           {
  959.                                              set("\x01",eval("\x01") + 31);
  960.                                           }
  961.                                        }
  962.                                        while(true)
  963.                                        {
  964.                                           if(eval("\x01") == 460)
  965.                                           {
  966.                                              set("\x01",eval("\x01") - 175);
  967.                                              ┬º┬ºpush(true);
  968.                                              continue;
  969.                                           }
  970.                                           if(eval("\x01") == 669)
  971.                                           {
  972.                                              set("\x01",eval("\x01") + 53);
  973.                                              if(┬º┬ºpop())
  974.                                              {
  975.                                                 set("\x01",eval("\x01") - 199);
  976.                                              }
  977.                                              continue;
  978.                                           }
  979.                                           if(eval("\x01") == 523)
  980.                                           {
  981.                                              break;
  982.                                           }
  983.                                           if(eval("\x01") == 188)
  984.                                           {
  985.                                              set("\x01",eval("\x01") + 578);
  986.                                              ┬º┬ºpush(true);
  987.                                              continue;
  988.                                           }
  989.                                           if(eval("\x01") == 781)
  990.                                           {
  991.                                              set("\x01",eval("\x01") - 164);
  992.                                           }
  993.                                           if(eval("\x01") == 157)
  994.                                           {
  995.                                              set("\x01",eval("\x01") + 31);
  996.                                              break loop1;
  997.                                           }
  998.                                           if(eval("\x01") != 722)
  999.                                           {
  1000.                                              if(eval("\x01") == 285)
  1001.                                              {
  1002.                                                 set("\x01",eval("\x01") + 340);
  1003.                                                 if(┬º┬ºpop())
  1004.                                                 {
  1005.                                                    set("\x01",eval("\x01") - 451);
  1006.                                                 }
  1007.                                                 continue;
  1008.                                              }
  1009.                                              if(eval("\x01") == 625)
  1010.                                              {
  1011.                                                 set("\x01",eval("\x01") - 451);
  1012.                                              }
  1013.                                              if(eval("\x01") == 174)
  1014.                                              {
  1015.                                                 set("\x01",eval("\x01") + 93);
  1016.                                                 ┬º┬ºpush(true);
  1017.                                                 continue;
  1018.                                              }
  1019.                                              if(eval("\x01") == 617)
  1020.                                              {
  1021.                                                 set("\x01",eval("\x01") + 52);
  1022.                                                 ┬º┬ºpush(true);
  1023.                                                 continue;
  1024.                                              }
  1025.                                              continue loop2;
  1026.                                           }
  1027.                                           set("\x01",eval("\x01") - 199);
  1028.                                           while(true)
  1029.                                           {
  1030.                                              set(┬º┬ºpop(),eval("\x01") - 355);
  1031.                                              ┬º┬ºpush(true);
  1032.                                              while(true)
  1033.                                              {
  1034.                                                 if(eval("\x01") == 414)
  1035.                                                 {
  1036.                                                    set("\x01",eval("\x01") + 571);
  1037.                                                    ┬º┬ºpush(true);
  1038.                                                 }
  1039.                                                 else if(eval("\x01") == 965)
  1040.                                                 {
  1041.                                                    set("\x01",eval("\x01") - 187);
  1042.                                                    if(┬º┬ºpop())
  1043.                                                    {
  1044.                                                       set("\x01",eval("\x01") - 69);
  1045.                                                    }
  1046.                                                 }
  1047.                                                 else if(eval("\x01") == 742)
  1048.                                                 {
  1049.                                                    set("\x01",eval("\x01") - 319);
  1050.                                                    if(┬º┬ºpop())
  1051.                                                    {
  1052.                                                       set("\x01",eval("\x01") + 148);
  1053.                                                    }
  1054.                                                 }
  1055.                                                 else if(eval("\x01") == 571)
  1056.                                                 {
  1057.                                                    set("\x01",eval("\x01") - 289);
  1058.                                                    ┬º┬ºpush(true);
  1059.                                                 }
  1060.                                                 else if(eval("\x01") == 517)
  1061.                                                 {
  1062.                                                    set("\x01",eval("\x01") + 271);
  1063.                                                    if(┬º┬ºpop())
  1064.                                                    {
  1065.                                                       set("\x01",eval("\x01") + 40);
  1066.                                                    }
  1067.                                                 }
  1068.                                                 else if(eval("\x01") == 828)
  1069.                                                 {
  1070.                                                    set("\x01",eval("\x01") - 488);
  1071.                                                    ┬º┬ºpush(true);
  1072.                                                 }
  1073.                                                 else
  1074.                                                 {
  1075.                                                    if(eval("\x01") == 509)
  1076.                                                    {
  1077.                                                       break;
  1078.                                                    }
  1079.                                                    if(eval("\x01") == 134)
  1080.                                                    {
  1081.                                                       set("\x01",eval("\x01") + 269);
  1082.                                                       if(┬º┬ºpop())
  1083.                                                       {
  1084.                                                          set("\x01",eval("\x01") - 337);
  1085.                                                       }
  1086.                                                    }
  1087.                                                    else if(eval("\x01") == 985)
  1088.                                                    {
  1089.                                                       set("\x01",eval("\x01") - 135);
  1090.                                                       if(┬º┬ºpop())
  1091.                                                       {
  1092.                                                          set("\x01",eval("\x01") - 341);
  1093.                                                       }
  1094.                                                    }
  1095.                                                    else if(eval("\x01") == 618)
  1096.                                                    {
  1097.                                                       set("\x01",eval("\x01") - 132);
  1098.                                                       ┬º┬ºpush(true);
  1099.                                                    }
  1100.                                                    else if(eval("\x01") == 282)
  1101.                                                    {
  1102.                                                       set("\x01",eval("\x01") - 130);
  1103.                                                       if(┬º┬ºpop())
  1104.                                                       {
  1105.                                                          set("\x01",eval("\x01") + 505);
  1106.                                                       }
  1107.                                                    }
  1108.                                                    else if(eval("\x01") == 860)
  1109.                                                    {
  1110.                                                       set("\x01",eval("\x01") - 118);
  1111.                                                       ┬º┬ºpush(true);
  1112.                                                    }
  1113.                                                    else if(eval("\x01") == 709)
  1114.                                                    {
  1115.                                                       set("\x01",eval("\x01") - 192);
  1116.                                                       ┬º┬ºpush(true);
  1117.                                                    }
  1118.                                                    else if(eval("\x01") == 154)
  1119.                                                    {
  1120.                                                       set("\x01",eval("\x01") + 651);
  1121.                                                       if(┬º┬ºpop())
  1122.                                                       {
  1123.                                                          set("\x01",eval("\x01") + 55);
  1124.                                                       }
  1125.                                                    }
  1126.                                                    else
  1127.                                                    {
  1128.                                                       if(eval("\x01") == 451)
  1129.                                                       {
  1130.                                                          set("\x01",eval("\x01") - 254);
  1131.                                                       }
  1132.                                                       if(eval("\x01") == 657)
  1133.                                                       {
  1134.                                                          set("\x01",eval("\x01") - 523);
  1135.                                                          ┬º┬ºpush(true);
  1136.                                                       }
  1137.                                                       else
  1138.                                                       {
  1139.                                                          if(eval("\x01") == 152)
  1140.                                                          {
  1141.                                                             set("\x01",eval("\x01") + 505);
  1142.                                                             break loop1;
  1143.                                                          }
  1144.                                                          if(eval("\x01") == 486)
  1145.                                                          {
  1146.                                                             set("\x01",eval("\x01") - 35);
  1147.                                                             if(┬º┬ºpop())
  1148.                                                             {
  1149.                                                                set("\x01",eval("\x01") - 254);
  1150.                                                             }
  1151.                                                          }
  1152.                                                          else
  1153.                                                          {
  1154.                                                             if(eval("\x01") == 850)
  1155.                                                             {
  1156.                                                                set("\x01",eval("\x01") - 341);
  1157.                                                                break loop1;
  1158.                                                             }
  1159.                                                             if(eval("\x01") == 112)
  1160.                                                             {
  1161.                                                                set("\x01",eval("\x01") + 506);
  1162.                                                                break loop1;
  1163.                                                             }
  1164.                                                             if(eval("\x01") == 805)
  1165.                                                             {
  1166.                                                                set("\x01",eval("\x01") + 55);
  1167.                                                             }
  1168.                                                             if(eval("\x01") == 423)
  1169.                                                             {
  1170.                                                                set("\x01",eval("\x01") + 148);
  1171.                                                                break loop1;
  1172.                                                             }
  1173.                                                             if(eval("\x01") == 403)
  1174.                                                             {
  1175.                                                                set("\x01",eval("\x01") - 337);
  1176.                                                             }
  1177.                                                             if(eval("\x01") == 778)
  1178.                                                             {
  1179.                                                                set("\x01",eval("\x01") - 69);
  1180.                                                             }
  1181.                                                             if(eval("\x01") == 0)
  1182.                                                             {
  1183.                                                                set("\x01",eval("\x01") + 965);
  1184.                                                                ┬º┬ºpush(true);
  1185.                                                             }
  1186.                                                             else if(eval("\x01") == 66)
  1187.                                                             {
  1188.                                                                set("\x01",eval("\x01") + 673);
  1189.                                                                ┬º┬ºpush(true);
  1190.                                                             }
  1191.                                                             else if(eval("\x01") == 340)
  1192.                                                             {
  1193.                                                                set("\x01",eval("\x01") - 228);
  1194.                                                                if(┬º┬ºpop())
  1195.                                                                {
  1196.                                                                   set("\x01",eval("\x01") + 506);
  1197.                                                                }
  1198.                                                             }
  1199.                                                             else
  1200.                                                             {
  1201.                                                                if(eval("\x01") != 739)
  1202.                                                                {
  1203.                                                                   if(eval("\x01") == 897)
  1204.                                                                   {
  1205.                                                                      set("\x01",eval("\x01") - 897);
  1206.                                                                   }
  1207.                                                                   if(eval("\x01") == 788)
  1208.                                                                   {
  1209.                                                                      set("\x01",eval("\x01") + 40);
  1210.                                                                   }
  1211.                                                                   if(eval("\x01") == 197)
  1212.                                                                   {
  1213.                                                                      set("\x01",eval("\x01") + 594);
  1214.                                                                      _root.beamOpen = false;
  1215.                                                                      _root.float = false;
  1216.                                                                      stop();
  1217.                                                                      break loop1;
  1218.                                                                   }
  1219.                                                                   if(eval("\x01") == 791)
  1220.                                                                   {
  1221.                                                                      set("\x01",eval("\x01") - 791);
  1222.                                                                   }
  1223.                                                                   break loop1;
  1224.                                                                }
  1225.                                                                set("\x01",eval("\x01") + 158);
  1226.                                                                if(┬º┬ºpop())
  1227.                                                                {
  1228.                                                                   set("\x01",eval("\x01") - 897);
  1229.                                                                }
  1230.                                                             }
  1231.                                                          }
  1232.                                                       }
  1233.                                                    }
  1234.                                                 }
  1235.                                              }
  1236.                                           }
  1237.                                        }
  1238.                                        set("\x01",eval("\x01") - 276);
  1239.                                        _root.speedY = 1;
  1240.                                        break loop1;
  1241.                                     }
  1242.                                     set("\x01",eval("\x01") + 424);
  1243.                                     var ┬º┬ºpop();
  1244.                                     ┬º┬ºpush(new ┬º┬ºpop()[┬º┬ºpop() >> ┬º┬ºpop()]());
  1245.                                     break;
  1246.                                  }
  1247.                                  if(eval("\x01") == 507)
  1248.                                  {
  1249.                                     set("\x01",eval("\x01") - 360);
  1250.                                     ┬º┬ºpush(true);
  1251.                                  }
  1252.                                  else if(eval("\x01") == 936)
  1253.                                  {
  1254.                                     set("\x01",eval("\x01") - 204);
  1255.                                     if(┬º┬ºpop())
  1256.                                     {
  1257.                                        set("\x01",eval("\x01") - 89);
  1258.                                     }
  1259.                                  }
  1260.                                  else if(eval("\x01") == 147)
  1261.                                  {
  1262.                                     set("\x01",eval("\x01") + 71);
  1263.                                     if(┬º┬ºpop())
  1264.                                     {
  1265.                                        set("\x01",eval("\x01") + 544);
  1266.                                     }
  1267.                                  }
  1268.                                  else
  1269.                                  {
  1270.                                     if(eval("\x01") != 152)
  1271.                                     {
  1272.                                        if(eval("\x01") == 985)
  1273.                                        {
  1274.                                           set("\x01",eval("\x01") - 848);
  1275.                                           stop();
  1276.                                           break;
  1277.                                        }
  1278.                                        if(eval("\x01") == 137)
  1279.                                        {
  1280.                                           set("\x01",eval("\x01") - 137);
  1281.                                        }
  1282.                                        break;
  1283.                                     }
  1284.                                     set("\x01",eval("\x01") + 59);
  1285.                                     if(┬º┬ºpop())
  1286.                                     {
  1287.                                        set("\x01",eval("\x01") + 774);
  1288.                                     }
  1289.                                  }
  1290.                               }
  1291.                            }
  1292.                         }
  1293.                      }
  1294.                   }
  1295.                }
  1296.             }
  1297.          }
  1298.       }
  1299.    }
  1300. }
  1301.